# Ephemeral Signers

**TLDR:** Avoid Ephemeral Signers in your transactions if possible. If not, prefer `SystemProgram.createAccountWithSeed` to `SystemProgram.createAccount`. If that doesn't work either use the `getEphemeralSigners` API exposed by SquadsX via the Wallet Standard interface.

**Problem**

Ephemeral Signer (ES) is a key that is expected to sign the transaction and be discarded right after. An example of when such ephemeral signers are needed is the `SystemProgram.createAccount` instruction. This instruction requires the new account to be a signer to verify that whoever calls this instruction actually holds authority over this account.

The `Keypair.generate()` method is typically used by app developers to create ephemeral signers, but this mechanism doesn't work with Smart Wallets that don't execute the transaction immediately. In these cases, the ephemeral keypair will not be available to sign the "execute" transaction because it has already been lost and forgotten.

**Solution 1**

Quite often you can avoid Ephemeral Signers completely by using `SystemProgram.createAccountWithSeed` instead of `SystemProgram.createAccount`. The difference between the two is that the latter requires the new account's signature, whereas the former doesn't because the new account is "controlled" by the `basePubkey` which most likely is your primary singer anyway.

For example, here's how you can do this in a transaction that typically requires an Ephemeral Signer: wrapping SOL via an auxiliary token account.

```jsx
// Generate a random seed.
const seed = Keypair.generate().publicKey.toBase58().slice(0, 32);

// Calculate a publicKey that will be controlled by the walletPubkey.
const auxAccountPubkey = await PublicKey.createWithSeed(
  walletPubkey,
  seed,
  TOKEN_PROGRAM_ID
);

// Create token account.
// Using `createAccountWithSeed` allows us to avoid the second signer,
// because this instruction requires signing only from `basePubkey`.
const createAccountIx = SystemProgram.createAccountWithSeed({
  fromPubkey: walletPubkey,
  basePubkey: walletPubkey,
  seed,
  newAccountPubkey: auxAccountPubkey,
  lamports: (await getMinimumBalanceForRentExemptAccount(connection)) + amount,
  space: ACCOUNT_SIZE,
  programId: TOKEN_PROGRAM_ID,
});// Some code
```

**Solution 2**

If the Solution 1 doesn't fit your needs, and you absolutely need a second signer in your transaction, we got you covered too. SquadsX exposes the `getEphemeralSigners` API that allows apps to request any number of ephemeral signers from the wallet. The wallet returns an array of account addresses that the app developer can use in their transactions. The API is exposed via the Wallet Standard feature detection mechanism and can be used as follows.

```jsx
import { useWallet } from "@solana/wallet-adapter-react";

const { wallet } = useWallet()

// ...
  
<button
  onClick={async () => {
    const adapter = wallet?.adapter;

    const ephemeralSignerAddress = adapter &&
      "standard" in adapter &&
      "fuse:getEphemeralSigners" in adapter.wallet.features &&
      (await adapter.wallet.features["fuse:getEphemeralSigners"].getEphemeralSigners(1))[0]

    const ephemeralSignerPubkey = ephemeralSignerAddress ? new Pubkey(ephemeralSignerAddress) : null

    // Use `ephemeralSignerPubkey` in your transaction.
  })}
/>// Some code
```

There's an open sRFC with the effort of making this feature into the Wallet Standard, so other wallets can implement it too. Once it happens, we hope that using`Keypair.generate` for creating Ephemeral Signers becomes a thing of a past.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.squads.so/main/squadsx-beta-development/guides/overcoming-integration-obstacles/ephemeral-signers.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.